// 起床的流程

// 起床
function getup(cb) {
    setTimeout(() => {
        // 起床结束 可以进行下一步
        console.log('起床结束！')

        cb()
    }, 1000)
}

// 刷牙
function shuaYa(cb) {
    setTimeout(() => {
        // 刷牙结束 可以进行下一步
        console.log('刷牙结束！')
        cb()
    }, 2000)
}

// 早餐
function breakfast(cb) {
    setTimeout(() => {
        // 早餐结束 可一进行下一步
        console.log('早餐结束！')
        cb()
    }, 3000)
}

// 出门
function moveOut() {
    setTimeout(() => {
        // 出门结束 可以进行下一步
        console.log('出门结束！')
    }, 1000)
}

// 同步编程的异步操作 事情一件接着一件做
// getup(() => {
//     shuaYa(() => {
//         breakfast(() => {
//             moveOut()
//         })
//     })
// })

// 但是这种写法看起来很难受 不容易理解
// 而且会遇到回调地狱问题： 即在回调函数里写回调函数...层层嵌套，难于理解 

// 于是ES6 创造了一种新的 异步机制 Promise：将回调地狱 转化为链式操作 逻辑更加清晰；
console.log('')
console.log('**************')
console.log('')

// 异步对象
const p = new Promise((resolve, reject) => {
    setTimeout(() => {
        console.log('异步操作1')
        resolve()
    }, 1000)
})

// promise 对象的 then 操作 表示接下来 做什么
// catch 表示 异常处理
p.then(() => {
        setTimeout(() => {
            console.log('异步操作2')
        }, 1000)
    }).then(() => {
        setTimeout(() => {
            console.log('异步操作3')
        }, 3000)
    })
    .catch(err => {
        console.log('失败！');
    })

// 参数传递

new Promise(res => {
    setTimeout(() => {
        res({
            a: 1
        })
    }, 1000)
}).then(date => console.log(date))


// promise.all 方法

function doWork(name) {
    return new Promise(done => {
        setTimeout(() => {
            done(name)
            console.log(name, 'done!')
        }, Math.random() * 2000)
    })
}

const arr = []
for (let i = 0; i < 10; i++) {
    arr.push(doWork(i))
}

Promise.all(arr).then(date => console.log('全部搞定！'))